static async Task RunClient(ClientFactory factory, ClientParameters parameters)
{
using (var client = await factory.Start(parameters)) {
var handler = ConnectionHandlerFactory.Echo.Create(client);
await handler.Run();
}
}
public static IServiceCollection AddClientWithFairwayTokenHandler(this IServiceCollection services, FairwayTokenClientOptions fairwayTokenClientOptions)
{
var clientParameters = new ClientParameters
{
ApiClientId = fairwayTokenClientOptions.ClientId,
ApiClientSecret = fairwayTokenClientOptions.ClientSecret
};
clientParameters.CustomFieldsCacheInitialization = EncompassApi.CacheInitialization.Never;
services.AddSingleton(clientParameters);
IOptions <FairwayTokenClientOptions> tokenClientIOptions = Options.Create(fairwayTokenClientOptions);
var retryPolicy = HttpPolicyExtensions.HandleTransientHttpError().RetryAsync(fairwayTokenClientOptions.RetryCount);
var timeoutPolicy = Policy.TimeoutAsync <HttpResponseMessage>(fairwayTokenClientOptions.TimeoutInSeconds);
services.AddSingleton(tokenClientIOptions);
services.AddHttpClient <ITokenClient, FairwayTokenClient>()
.AddPolicyHandler(retryPolicy)
.AddPolicyHandler(timeoutPolicy);
services.AddHttpClient <IEncompassApiClient, EncompassApiService>(c =>
{
c.BaseAddress = new Uri(fairwayTokenClientOptions.BaseUrl);
})
.AddHttpMessageHandler <TokenHandler>()
.AddPolicyHandler(retryPolicy)
.AddPolicyHandler(timeoutPolicy);
services.AddTransient <IEncompassApiClient>(sp => new EncompassApiService(sp.GetService <IHttpClientFactory>().CreateClient("EncompassClient"), clientParameters));
return(services);
}
public IdentitySeedData(IConfiguration configuration)
{
this.configuration = configuration;
var client = new ClientParameters(configuration.GetClientSecurityString(), this.configuration.GetClientAuthorityString());
this.IdentityResources = new List <IClientParameters>
{
client,
}.Identity();
this.ApiResources = new List <IApiParameters>
{
new ApiParameters(),
}.Api();
this.Clients = new List <Client>
{
client.Mvc(),
};
this.Users = new List <IUser>
{
new Alice(),
new Bob(),
};
}
public async Task AccessToken_RevokeOnDisposeAsync()
{
ClientParameters clientParameters = null;
var client = await GetTestClientAsync(cp => { clientParameters = cp; });
var accessToken = client.AccessToken;
var token = accessToken.Token;
if (token != "Token")
{
TokenIntrospectionResponse response;
await using (client)
{
response = await accessToken.IntrospectAsync();
Assert.IsTrue(response.Active);
}
using (await EncompassRestClient.CreateFromAccessTokenAsync(clientParameters, token))
{
response = await accessToken.IntrospectAsync();
Assert.IsNull(response);
}
}
}
/// <summary>
/// Initializes a new instance of the <see cref="FilterSettings"/> class.
/// </summary>
/// <param name="clientParameters">The ClientParameters.</param>
public FilterSettings(ClientParameters clientParameters)
{
PersonWhereSearch = ArrayQSFilterSetting.CreateInstance().InitFromQueryString("PersonWhereSearch", clientParameters.PersonWhereSearch).SetEnable(true);
PersonHowSearch = PersonHowSearchFilterSetting.CreateInstance().InitFromQueryString("PersonHowSearch", clientParameters.PersonHowSearch).SetEnable(true);
Search = StringQSFilterSetting.CreateInstance().InitFromQueryString("Search", "");
PersonValidAt = StringQSFilterSetting.CreateInstance().InitFromQueryString("PersonValidAt", "");
PersonType = ArrayQSFilterSetting.CreateInstance().InitFromQueryString("PersonType", clientParameters.PersonType);
Veracity = ArrayQSFilterSetting.CreateInstance().InitFromQueryString("PersonCheck", clientParameters.PersonCheck);
Uri myUri = new Uri(HttpContext.Current.Request.Url.AbsoluteUri);
string PersonAllBProject = HttpUtility.ParseQueryString(myUri.Query).Get("PersonAllBProject");
clientParameters.PersonAllBProject = Convert.ToInt32(PersonAllBProject);
BusinessProject = BusinessProjectFilterSetting.CreateInstance().InitFromQS(
"PersonBProject", (clientParameters.PersonBProject == "" ? "0" : clientParameters.PersonBProject),
"PersonSubBProject ", clientParameters.PersonSubBProject,
"PersonAllBProject ", clientParameters.PersonAllBProject);
if (clientParameters.PersonAllBProject != 0)
{
BusinessProject.SetEnable(true);
}
PersonArea = PersonAreaFilterSetting.CreateInstance().InitFromQueryString("PersonArea", clientParameters.PersonArea == "" ? "0" : clientParameters.PersonArea);
PersonOPForma = UniqueIdQSFilterSetting.CreateInstance().InitFromQueryString("PersonOPForma", clientParameters.PersonOPForma);
PersonUsers = PersonUsersFilterSetting.CreateInstance()
.SetListAccessor(ids => Kesco.Employees.BusinessLogic.Repository.Employees.GetListByIds(ids))
.InitFromQueryString("PersonUsers", clientParameters.PersonUsers);
PersonThemes = PersonThemesFilterSetting.CreateInstance()
.SetListAccessor(ids => Repository.PersonThemes.GetListByIds(ids))
.InitFromQS("PersonThemes", clientParameters.PersonThemes,
"PersonSubThemes", clientParameters.PersonSubThemes);
PersonTUnion = StringQSFilterSetting.CreateInstance().InitFromQueryString("PersonTUnion", "");
PersonLink = StringQSFilterSetting.CreateInstance().InitFromQueryString("PersonLink", "");
int personID;
if (int.TryParse(PersonLink.GetValue(), out personID))
{
var p = Repository.Persons.GetInstance(personID);
PersonLinkNickname = p != null ? p.Nickname : "#PersonLink";
}
else
{
PersonLinkNickname = "";
}
PersonLinkType = StringQSFilterSetting.CreateInstance().InitFromQueryString("PersonLinkType", "");
PersonForSend = StringQSFilterSetting.CreateInstance().InitFromQueryString("PersonForSend", "0");
PersonAdvSearch = StringQSFilterSetting.CreateInstance().InitFromQueryString("PersonAdvSearch", "");
//PersonSelectTop = PersonSelectTopFilterSetting.CreateInstance().InitFromQueryString("PersonSelectTop", 30);
}
internal static RemoteCertificateValidationCallback GetValidationCallback (ClientParameters parameters)
{
var validator = parameters.ClientCertificateValidator;
if (validator == null)
return null;
return ((CertificateValidator)validator).ValidationCallback;
}
static ClientParameters GetClientParameters()
{
var clientParameters = new ClientParameters();
clientParameters.VerifyPeerCertificate = false;
clientParameters.TrustedCA = ResourceManager.LocalCACertificate;
return(clientParameters);
}
public async Task <PagedList <Client> > GetAllPagesAsync(ClientParameters parameters)
{
IQueryable <Client> clients = FindByConditionAsync(x => x.Id > 0);
SearchByLastName(ref clients, parameters.LastName);
clients = sortHelper.ApplySort(clients, parameters);
return(await PagedList <Client> .ToPagedListAsync(clients, parameters.PageNumber, parameters.PageSize));
}
static void ClientLoop(ClientFactory factory, ClientParameters parameters)
{
for (int i = 0; i < 10; i++)
{
RunClient(factory, parameters).Wait();
Thread.Sleep(500);
}
}
public static void DoMain(string[] args)
{
Program <T> .KeepRunning = true;
Console.CancelKeyPress += new ConsoleCancelEventHandler(Console_CancelKeyPress);
var program = (T)Activator.CreateInstance(typeof(T));
program.Parameters = ClientParameters.FromConfig();
program.Run();
}
/// <summary>
/// Do not dispose of this object as it is reused on tests
/// </summary>
/// <returns></returns>
public static async Task <IEncompassApiClient> GetTestClientAsync(Action <ClientParameters> parametersInitializer = null)
{
var client = s_testClient;
if (client == null || parametersInitializer != null)
{
const string testClientCredentialsFile = "C:\\EncompassApiTestClientCredentials.json"; // Never include this file in source control
//if (File.Exists(testClientCredentialsFile))
//{
// TestClientCredentials credentials;
// using (var fs = File.OpenRead(testClientCredentialsFile))
// {
// using (var sr = new StreamReader(fs))
// {
// credentials = JsonHelper.FromJson<TestClientCredentials>(sr);
// }
// }
// var effectiveParameters = credentials.Parameters;
// if (parametersInitializer != null)
// {
// effectiveParameters = JsonHelper.DefaultPublicSerializer.Clone(effectiveParameters);
// parametersInitializer(effectiveParameters);
// }
// //TODO Rewrite
// client = await EncompassApiClient.CreateAsync(effectiveParameters, tc => tc.FromUserCredentialsAsync(credentials.InstanceId, credentials.UserId, credentials.Password));
// Console.WriteLine("Using test client credentials file");
//}
//else
//{
IClientParameters parameters = new ClientParameters
{
ApiClientId = "ApiClientId",
ApiClientSecret = "ApiClientSecret"
};
client = new EncompassApiClient(parameters);
//TODO Rewrite
//var accessToken = client.AccessToken;
//accessToken.Token = "Token";
var httpClient = client.HttpClient;
httpClient.BaseAddress = new Uri("https://try.readme.io/");
var defaultRequestHeaders = httpClient.DefaultRequestHeaders;
defaultRequestHeaders.Clear();
defaultRequestHeaders.Add("x-api-key", "9JsmcmHyzJuokoWeJJ8HGiRgS5GR8cSKVswz");
defaultRequestHeaders.Add("origin", string.Empty);
//await parameters.TryInitializeAsync(client, client.CommonCache, CancellationToken.None);
Console.WriteLine("Using Encompass Developer Connect Try It endpoint");
//}
if (parametersInitializer == null)
{
client = Interlocked.CompareExchange(ref s_testClient, client, null) ?? client;
}
}
return(client);
}
internal static X509Certificate2Collection GetClientCertificates (ClientParameters parameters)
{
if (parameters.ClientCertificate == null)
return null;
var clientCertificateCollection = new X509Certificate2Collection ();
var certificate = (X509Certificate2)CertificateProvider.GetCertificate (parameters.ClientCertificate);
clientCertificateCollection.Add (certificate);
return clientCertificateCollection;
}
public async Task <IActionResult> GetAllClients([FromQuery] ClientParameters parameters = null)
{
var clients = await _repository.Client.GetAllClientsAsync(parameters);
if (!clients.Any())
{
return(NoContent());
}
_logger.LogInformation($"Returned all clients");
var clientsResult = _mapper.Map <IEnumerable <ClientReadDto> >(clients);
return(Ok(clientsResult));
}
private string GetClientParameters()
{
var referrer = HttpContext.Request.Headers["referer"].ToString();
if (!string.IsNullOrWhiteSpace(referrer) && Uri.TryCreate(referrer, UriKind.Absolute, out var uri))
{
var parameters = new ClientParameters
{
Referrer = uri
};
return(HttpUtility.HtmlAttributeEncode(parameters.ToJson()));
}
return(new object().ToJson());
}
public async Task <IEnumerable <Client> > GetAllClientsAsync(ClientParameters parameters)
{
if (parameters.SalesmanId == 0)
{
return(await FindAll()
.Include(c => c.Address)
.OrderBy(client => client.CompanyName)
.ToListAsync());
}
else
{
return(await FindByCondition(c => c.SalesmanId.Equals(parameters.SalesmanId))
.Include(c => c.Address)
.OrderBy(client => client.CompanyName)
.ToListAsync());
}
}
private void AddClientWithFairwayTokenHandlerandInterceptor(IFunctionsHostBuilder builder)
{
var fairwayTokenClientOptions = ConfigHelper.GetFairwayTokenClientOptions();
var encompassClientOptions = ConfigHelper.GetEncompassClientOptions();
var clientParameters = new ClientParameters
{
ApiClientId = fairwayTokenClientOptions.ClientId,
ApiClientSecret = fairwayTokenClientOptions.ClientSecret
};
clientParameters.CustomFieldsCacheInitialization = EncompassApi.CacheInitialization.Never;
var headers = new EncompassHttpResponseHeaderLoggerOptions();
headers.AddRange("X-Concurrency-Limit-Limit", "X-Concurrency-Limit-Remaining", "X-Rate-Limit-Limit", "X-Rate-Limit-Remaining", "X-Rate-Limit-Reset");
var fairwayIOptions = Options.Create(fairwayTokenClientOptions);
builder.Services.AddSingleton(clientParameters);
builder.Services.AddSingleton(fairwayIOptions);
builder.Services.AddFairwayTokenHandler(fairwayTokenClientOptions)
.AddPolicyHandler(HttpPolicyExtensions.HandleTransientHttpError().RetryAsync(fairwayTokenClientOptions.RetryCount))
.AddPolicyHandler(Policy.TimeoutAsync <HttpResponseMessage>(fairwayTokenClientOptions.TimeoutInSeconds));
builder.Services.AddEncompassHttpClient(options =>
{
options.CompressionOptions = new HttpClientCompressionHandlerOptions()
{
DecompressionMethods = new DecompressionMethods[] { DecompressionMethods.GZip },
EnableAutoDecompression = true
};
options.ClientParameters = clientParameters;
options.EncompassHttpResponseHeaderLoggerOptions = headers;
options.EncompassClientOptions = encompassClientOptions;
},
config => config.BaseAddress = new Uri(encompassClientOptions.BaseUrl))
.AddEncompassTokenMessageHandler()
.AddEncompassHttpResponseHeaderLoggingHandler()
.AddEncompassMessageHandler(sp => new AuthHeaderInterceptorHandler(sp.GetService <ILogger <AuthHeaderInterceptorHandler> >()))
.AddEncompassRetryPolicyHandler()
.AddEncompassTimeoutPolicyHandler()
.Build(builder.Services);
}
static void ReadParameters()
{
if (isTestMode)
{
clientParameters.SetServerIP("192.168.0.106");
clientParameters.ServerPort = 10086;
clientParameters.OnlineAvatar = "";
clientParameters.ServiceName = "";
}
else
{
string filePath = System.Reflection.Assembly.GetExecutingAssembly().Location;
clientParameters = ClientParametersManager.ReadParameters(filePath);
}
Console.WriteLine("参数信息：");
Console.WriteLine("IP:" + clientParameters.GetServerIP());
Console.WriteLine("PORT：" + clientParameters.ServerPort);
}
private string GetClientParameters()
{
// Uncomment to enable testing /ide without going through orchestrator
// var referrer = "http://localhost:4242";
var referrer = HttpContext.Request.Headers["referer"].ToString();
if (!string.IsNullOrWhiteSpace(referrer) && Uri.TryCreate(referrer, UriKind.Absolute, out var uri))
{
var parameters = new ClientParameters
{
Referrer = uri
};
return(HttpUtility.HtmlAttributeEncode(parameters.ToJson()));
}
return(new object().ToJson());
}
static void Client(params string[] args)
{
ClientFactory factory = Factory.DotNetClient;;
int repeat = 0;
var parameters = new ClientParameters();
parameters.VerifyPeerCertificate = false;
var p = new OptionSet {
{ "client=", v => factory = ConnectionFactoryProvider.GetClientFactory(v) },
{ "verbose", v => parameters.EnableDebugging = true },
{ "verify", v => parameters.VerifyPeerCertificate = true }
};
var extra = p.Parse(args);
if (extra.Count != 0)
{
throw new InvalidOperationException();
}
if (parameters.VerifyPeerCertificate)
{
parameters.TrustedCA = ResourceManager.LocalCACertificate;
}
if (repeat < 0)
{
repeat = int.MaxValue;
}
else if (repeat == 0)
{
repeat = 1;
}
for (int i = 0; i < repeat; i++)
{
RunClient(factory, parameters).Wait();
}
}
public static IServiceCollection AddClientWithEncompassTokenHandler(this IServiceCollection services, EncompassTokenClientOptions encompassTokenClientOptions)
{
var clientParameters = new ClientParameters
{
ApiClientId = encompassTokenClientOptions.ClientId,
ApiClientSecret = encompassTokenClientOptions.ClientSecret
};
clientParameters.CustomFieldsCacheInitialization = EncompassApi.CacheInitialization.Never;
services.AddSingleton(clientParameters);
IOptions <EncompassTokenClientOptions> options = Options.Create(encompassTokenClientOptions);
var retryPolicy = HttpPolicyExtensions.HandleTransientHttpError().RetryAsync(encompassTokenClientOptions.RetryCount);
var timeoutPolicy = Policy.TimeoutAsync <HttpResponseMessage>(encompassTokenClientOptions.TimeoutInSeconds);
services.AddSingleton(options);
services.AddHttpClient <ITokenClient, EncompassTokenClient>(c =>
{
c.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic",
Convert.ToBase64String(
Encoding.UTF8.GetBytes(
$"{WebUtility.UrlEncode(encompassTokenClientOptions.ClientId)}:{WebUtility.UrlEncode(encompassTokenClientOptions.ClientSecret)}")));
})
.AddPolicyHandler(retryPolicy)
.AddPolicyHandler(timeoutPolicy);
services.AddHttpClient <IEncompassApiClient, EncompassApiService>(c =>
{
c.BaseAddress = new Uri(encompassTokenClientOptions.BaseUrl);
})
.AddHttpMessageHandler <TokenHandler>()
.AddPolicyHandler(retryPolicy)
.AddPolicyHandler(timeoutPolicy);
return(services);
}
static ClientParameters ReadParameters()
{
ClientParameters paras = new ClientParameters();
if (isTestMode)
{
paras.SetServerIP("192.168.1.136");
paras.ServerPort = 10086;
paras.OnlineAvatar = "";
paras.ServiceName = "";
}
else
{
string filePath = System.Reflection.Assembly.GetExecutingAssembly().Location;
paras = ClientParametersManager.ReadParameters(filePath);
}
Console.WriteLine("参数信息：");
Console.WriteLine("IP:" + paras.GetServerIP());
Console.WriteLine("PORT：" + paras.ServerPort);
return(paras);
}
/// <summary>
/// Gets the js arguments passed to this method call.
/// </summary>
public string JsArguments(string obj = "", bool callback = false)
{
string result;
if (obj != "")
{
result = string.Join(", ", ClientParameters.Select(f => $"{obj}.{f.Name.ToCamelCase()}()"));
}
else
{
result = string.Join(", ", ClientParameters.Select(f => obj + f.Name.ToCamelCase()));
}
if (callback)
{
if (!string.IsNullOrEmpty(result))
{
result = result + ", ";
}
result = result + "callback";
}
return(result);
}
public async Task<MonoSslStream> CreateClientStreamAsync (Stream stream, string targetHost, ClientParameters parameters, MSI.MonoTlsSettings settings, CancellationToken cancellationToken)
{
var protocol = GetProtocol (parameters, false);
MSI.ICertificateValidator validator = null;
if (settings != null)
CallbackHelpers.AddCertificateValidator (settings, parameters.ClientCertificateValidator);
else
validator = CallbackHelpers.GetCertificateValidator (parameters.ClientCertificateValidator);
var clientCertificates = CallbackHelpers.GetClientCertificates (parameters);
var sslStream = tlsProvider.CreateSslStream (stream, false, validator, settings);
var monoSslStream = new MonoSslStream (sslStream);
try {
await sslStream.AuthenticateAsClientAsync (targetHost, clientCertificates, protocol, false).ConfigureAwait (false);
} catch (Exception ex) {
var lastError = monoSslStream.LastError;
if (lastError != null)
throw new AggregateException (ex, lastError);
throw;
}
return monoSslStream;
}
public Task<MonoSslStream> CreateClientStreamAsync (Stream stream, string targetHost, ClientParameters parameters, CancellationToken cancellationToken)
{
return CreateClientStreamAsync (stream, targetHost, parameters, null, cancellationToken);
}
async Task<ISslStream> ISslStreamProvider.CreateClientStreamAsync (Stream stream, string targetHost, ClientParameters parameters, CancellationToken cancellationToken)
{
return await CreateClientStreamAsync (stream, targetHost, parameters, cancellationToken).ConfigureAwait (false);
}
public override IClient CreateClient (ClientParameters parameters)
{
if (SupportsMonoExtensions)
return new MonoClient (this, parameters);
else
return new DotNetClient (this, parameters, this);
}
public CipherInstrumentParameters (InstrumentationCategory category, CipherInstrumentType type, ClientParameters clientParameters, ServerParameters serverParameters)
: base (category, clientParameters, serverParameters)
{
Type = type;
}
public abstract IMonoClient CreateMonoClient (ClientParameters parameters);
public Client()
{
Log.LogInfo("Setting up Client...", LogType.Application_Work);
KeepWorking = true;
if (!File.Exists(AppDomain.CurrentDomain.BaseDirectory + Globals.PARAMETERS_PATH))
{
JSONManagement.WriteToJsonFile <ClientParameters>(
AppDomain.CurrentDomain.BaseDirectory + Globals.PARAMETERS_PATH,
new ClientParameters(8407, "127.0.0.1"));
}
ClientParameters clientParameters = JSONManagement.ReadFromJsonFile <ClientParameters>(AppDomain.CurrentDomain.BaseDirectory + Globals.PARAMETERS_PATH);
this.Port = clientParameters.port;
this.Hostname = clientParameters.ipAddress;
CancellationTokenSource cts = new CancellationTokenSource();
CancellationToken ct = cts.Token;
Action action = () => Connect(ct);
//start trying to connect
Task task = new Task(action, ct);
task.Start();
//event subscribing for disconnecting when app closes
AppDomain.CurrentDomain.ProcessExit += CurrentDomain_ProcessExit;
//wait 15 sec (in ms) before timeout
if (task.Wait(15000))
{
Log.LogInfo("Connected to server", LogType.Connection_To_Server);
Console.WriteLine("Connected to server " + Hostname + ":" + Port);
}
else
{
Log.LogInfo("Connection to server failed", LogType.Connection_To_Server);
Console.WriteLine("Could not connect to server " + Hostname + ":" + Port);
}
cts.Cancel();
cts.Dispose();
task.Wait();
task.Dispose();
Log.LogInfo("Shutting down the connection process.", LogType.Application_Work);
Console.WriteLine("you are now connected to the chat server");
State = ClientState.Login;
do
{
switch (State)
{
case ClientState.Login:
Login();
break;
case ClientState.Disconnecting:
Disconnect();
break;
case ClientState.Working:
Work();
break;
case ClientState.Exiting:
break;
default:
break;
}
} while (State != ClientState.Disconnecting);
Console.ReadLine();
}
private void buttonGenClient_Click(object sender, EventArgs e)
{
string serverIP = this.textBoxServerIP.Text.Trim();
string serverPort = this.textBoxServerPort.Text.Trim();
int serverPortNum;
if (!int.TryParse(serverPort, out serverPortNum))
{
return;
}
if (string.IsNullOrWhiteSpace(this.textBoxServiceName.Text))
{
return;
}
string serviceName = this.textBoxServiceName.Text.Trim();
string avatar = this.pictureBoxAvatar.Tag.ToString();
bool showOriginalFilename = this.checkBoxShowOriginalFileName.Checked;
// 保存配置
this.buttonSaveServerSetting.PerformClick();
SaveFileDialog dialog = new SaveFileDialog();
dialog.Filter = "可执行程序(*.exe)|*.exe|所有文件(*.*)|*.*";
dialog.FilterIndex = 1;
dialog.InitialDirectory = Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
if (dialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
ClientParameters para = new ClientParameters();
para.SetServerIP(serverIP);
para.ServerPort = serverPortNum;
para.ServiceName = serviceName;
para.OnlineAvatar = avatar;
byte[] fileBytes = null;
if (System.IO.File.Exists("RemoteControl.Client.dat"))
{
// 读取本地文件
fileBytes = System.IO.File.ReadAllBytes("RemoteControl.Client.dat");
}
else
{
MsgBox.Info("RemoteControl.Client.dat文件丢失！");
return;
// 读取资源文件
//fileBytes = ResUtil.GetResFileData("RemoteControl.Client.dat");
}
// 拷贝文件
System.IO.File.WriteAllBytes(dialog.FileName, fileBytes);
// 修改图标
if (this.checkBoxAppIcon.Checked && this.pictureBoxAppIcon.Tag != null && System.IO.File.Exists(this.pictureBoxAppIcon.Tag.ToString()))
{
IconChanger.ChangeIcon(dialog.FileName, this.pictureBoxAppIcon.Tag as string);
}
fileBytes = System.IO.File.ReadAllBytes(dialog.FileName);
// 修改启动模式
ClientParametersManager.WriteClientStyle(fileBytes,
this.checkBoxHideClient.Checked ? ClientParametersManager.ClientStyle.Hidden : ClientParametersManager.ClientStyle.Normal);
if (!showOriginalFilename)
{
// 隐藏原始文件名
ClientParametersManager.HideOriginalFilename(fileBytes);
}
// 修改参数
ClientParametersManager.WriteParameters(fileBytes, dialog.FileName, para);
MsgBox.Info("客户端生成成功！");
}
}
public MonoClientAndServerParameters (ClientParameters clientParameters, ServerParameters serverParameters)
: base (clientParameters, serverParameters)
{
}
public InstrumentationParameters (InstrumentationCategory category, ClientParameters clientParameters, ServerParameters serverParameters)
: base (clientParameters, serverParameters)
{
Category = category;
}
//public async Task<Client> GetClientDetailsByIdAsync(int Id) => // await unitOfWork.ClientRepository.GetClientDetailsByIdAsync(Id); //public async Task<List<Client>> GetClientDetailsAsync() => // await unitOfWork.ClientRepository.GetClientDetailsAsync(); public async Task <PagedList <ClientDTO> > GetClientPages(ClientParameters parameters) => mapper.Map <PagedList <ClientDTO> >(await unitOfWork.ClientRepository.GetAllPagesAsync(parameters));
public override IMonoClient CreateMonoClient (ClientParameters parameters)
{
if (!SupportsMonoExtensions)
throw new InvalidOperationException ();
return new MonoClient (this, parameters);
}
public override IMonoClient CreateMonoClient (ClientParameters parameters)
{
return new OpenSslClient (this, parameters);
}
public OpenSslClient (OpenSslConnectionProvider provider, ClientParameters parameters)
: base (provider, parameters)
{
}
public override IClient CreateClient (ClientParameters parameters)
{
return CreateMonoClient (parameters);
}
public SignatureInstrumentParameters (InstrumentationCategory category, SignatureInstrumentType type, ClientParameters clientParameters, ServerParameters serverParameters)
: base (category, clientParameters, serverParameters)
{
Type = type;
}
public SimpleConnectionParameters (InstrumentationCategory category, SimpleConnectionType type, ClientParameters clientParameters, ServerParameters serverParameters)
: base (category, clientParameters, serverParameters)
{
Type = type;
}
