private void AsyncAccept(IAsyncResult ar)
{
try
{
var reverseProxyClient = new ReverseProxyClient(_socket.EndAccept(ar));
reverseProxyClient.Connect += ReverseProxyClientOnConnect;
reverseProxyClient.Disconnected += ReverseProxyClientOnDisconnected;
reverseProxyClient.SendDataPacket += ReverseProxyClientOnSendDataPacket;
lock (_clientsLock)
_clients.Add(reverseProxyClient);
reverseProxyClient.Initialize();
ClientAdded?.Invoke(this, reverseProxyClient);
}
catch
{
// ignored
}
try
{
_socket.BeginAccept(AsyncAccept, null);
}
catch
{
// Server stopped listening
}
}
private void UpdateClient(RemoteClient remoteClient, T data)
{
var found = false;
foreach (var entry in Swarm)
{
if (entry.Key.Equals(remoteClient))
{
entry.Key.State = remoteClient.State;
Swarm.TryUpdate(entry.Key, data, entry.Value);
ClientChanged?.Invoke(remoteClient, entry.Value);
found = true;
}
if (DateTime.UtcNow.Subtract(entry.Key.LastMessage.Sent) > _coordinator.ClientExpiryTime)
{
T removed;
if (Swarm.TryRemove(entry.Key, out removed))
{
ClientExpired?.Invoke(remoteClient, removed);
}
}
}
if (!found)
{
Swarm.TryAdd(remoteClient, data);
ClientAdded?.Invoke(remoteClient, data);
}
ClientsUpdated?.Invoke();
}
public virtual bool AddClient(IStudioComponent client)
{
if (AddClientStudioComponent(client))
{
ClientAdded?.Invoke(this, client);
return(true);
}
return(false);
}
private void Button_Click(object sender, RoutedEventArgs e)
{
ClientAdded?.Invoke(this, new Client()
{
Id = Convert.ToInt32(Id.Text),
Name = Name.Text,
Deposit = Convert.ToInt32(Deposit.Text),
Type = Type.Text
});
}
public void AddListener(RoomObserverBase observer)
{
if (!Clients.Contains(observer))
{
Clients.AddLast(observer);
if (observer.client.Role.GetType() != typeof(Admin))
{
ClientAdded?.Invoke(Name, observer.client.Username);
}
}
}
private static async void Listen()
{
while (Listener != null)
{
TcpClient NewClient = await Listener.AcceptTcpClientAsync();
NetworkClient NewNetworkClient = new NetworkClient(NewClient, ProcessingModules);
_Clients.Add(NewNetworkClient);
ClientAdded?.Invoke(NewNetworkClient);
}
}
public void Add(IClient client)
{
if (client is null)
{
throw new ArgumentNullException(nameof(client));
}
client.ConnectionClosed += HandleClientConnectionClosed;
_clients.Add(client);
ClientAdded?.Invoke(this, new ClientAddedEventArgs(client));
}
public void AddClient(IRailNetPeer netPeer, string identifier)
{
if (clients.ContainsKey(netPeer) == false)
{
RailServerPeer client = new RailServerPeer(Resource, netPeer, Interpreter)
{
Identifier = identifier
};
client.EventReceived += OnEventReceived;
client.PacketReceived += OnPacketReceived;
clients.Add(netPeer, client);
Room.AddClient(client);
ClientAdded?.Invoke(client);
}
}
private static async void Listen(Func <TcpListener> TargetListenerGetter)
{
while (TargetListenerGetter() != null)
{
try
{
TcpClient NewClient = await TargetListenerGetter().AcceptTcpClientAsync();
NetworkClient NewNetworkClient = new NetworkClient(NewClient, AuthenticationCallback, ProcessingModules);
_Clients.Add(NewNetworkClient);
ClientAdded?.Invoke(NewNetworkClient);
}
catch (ObjectDisposedException) { }
}
}
/// <summary>
/// Добавление клиента
/// </summary>
/// <param name="client">Информация о клиенте</param>
public void AddClient(Client client)
{
if (!client.IsValid)
{
throw new InvalidClientException("Информация о клиент заполнена некорректно");
}
try
{
_clients.Add(client.ClientId, client);
//Герерируем событие о том, что клиент добавлен
ClientAdded?.Invoke(client, EventArgs.Empty);
}
catch (System.Exception exception)
{
throw new InvalidClientException("При добавлении клиента произошла ошибка", exception);
}
}
/// <summary>
/// Метод добавления юр.лица в БД
/// </summary>
/// <param name="lastName">фамилия</param>
/// <param name="firstName">имя</param>
/// <param name="middleName">отчество</param>
/// <param name="series">серия паспорта</param>
/// <param name="number">номер паспорта</param>
/// <param name="address">адрес</param>
/// <param name="phoneNumber">номер телефона</param>
/// <param name="email">эмейл</param>
/// <param name="cardName">наименование карты</param>
/// <param name="accountType">тип аккаунта</param>
/// <returns>признак успешного добавления, сообщение</returns>
public static (bool successfully, string message) AddEntityToDb(string lastName, string firstName, string middleName,
string series, string number,
string address,
string phoneNumber, string email,
string nameOfCompany, string website,
string cardName, AccountType accountType)
{
using (AppDbContext context = new AppDbContext())
{
var(passport, contact, account) = CreateBaseRequisites(lastName, firstName, middleName, series, number, address, phoneNumber, email, cardName, accountType);
//Данные компании
var company = CompanyFactory.CreateCompany(nameOfCompany, website);
//Создание юр.лица
var entity = EntityFactory.CreateEntity(passport, contact, account, company);
//Проверка на совпадения в реквизитах
var(noMatchesFound, message) = SearchForMatchesForAdding.EntityErrorProcessing(passport, contact, company);
if (noMatchesFound)
{
context.Clients.Add(entity);
context.SaveChanges();
message = "Произведена операция добавления:\n" +
$"Клиент: {entity.Passport.FullName.Name}\n" +
$"Карта: {entity.Account.Card.CardName}\n" +
$"Номер: {entity.Account.Card.CardNumber}\n" +
$"Статус: {(entity.Account is RegularAccount ? "Стандарт" : "VIP")}\n" +
$"Дата: {DateTime.Now : dd/MM/yyyy HH:mm:ss}\n" +
"Отчет: Успешно";
ClientAdded?.Invoke(null, new AddClientEventArgs {
LogMessage = message
});
}
return(noMatchesFound, message);
}
}
async void OnSave(object sender, EventArgs e)
{
ClientViewModel client = new ClientViewModel
{
FirstName = FirstName.Text,
LastName = LastName.Text,
Address = Address.Text,
City = City.Text,
Zip = Zip.Text,
County = County.Text,
PhoneNumber = PhoneNumber.Text
};
BindingContext = new ClientViewModel
{
Id = client.Id,
FirstName = client.FirstName,
LastName = client.LastName,
Address = client.Address,
City = client.City,
Zip = client.Zip,
County = client.County,
PhoneNumber = client.PhoneNumber
};
if (client.Id == 0)
{
await _connection.InsertAsync(client);
ClientAdded?.Invoke(this, client);
}
else
{
await _connection.UpdateAsync(client);
ClientUpdated?.Invoke(this, client);
}
await Navigation.PopAsync();
//OnPropertyChanged("client");
}
public void Listen()
{
m_Listener = new TcpListener(m_ListenIP, m_Port);
m_Listener.Start();
m_AcceptTask = Task.Factory.StartNew(
() =>
{
while (true)
{
try
{
var acceptedClient = m_Listener.AcceptTcpClient();
lock (m_Clients)
{
m_Clients.Add(acceptedClient);
m_ReadonlyClients = m_Clients.ToArray();
ClientAdded?.Invoke(
this,
new TcpClientEventArgs
{
Client = acceptedClient
});
if (m_Clients.Count == 1)
{
Receive();
}
}
}
catch (SocketException ex) when(ex.ErrorCode == 10004)
{
Console.WriteLine("連線關閉");
break;
}
}
},
TaskCreationOptions.LongRunning);
}
/// <summary>
/// Method called on client added routed event.
/// </summary>
/// <param name="sender">The <see cref="object"/> sender of the event.</param>
/// <param name="e">The routed event arguments <see cref="RoutedEventArgs"/></param>
private void RaiseClientAdded(object sender, RoutedEvent e)
{
ClientAdded?.Invoke(this, new RoutedEventArgs(e, sender));
}
private void OnClientAdded(string obj) => ClientAdded?.Invoke(obj);
public void AddClient(ActiveCommandInfo activeCommandInfo, Client client)
{
ClientAdded?.Invoke(this, new ActiveCommandClientEventArgs(activeCommandInfo, client));
}
public void When(ClientAdded clientAdded)
{
ClientId = clientAdded.ClientId;
Name = (ClientName)clientAdded.Name;
Email = (Email)clientAdded.Email;
}
private void OnClientAdded(string clientKey, ITcpClient client) => ClientAdded?.Invoke(this, new TcpIpListenerAddedClient12EventArgs(clientKey, client));
private void EnregistrerExcecute()
{
ID = Srv.AddClient(Client);
ClientAdded?.Invoke(this, EventArgs.Empty);
}
private void OnClientAdded()
{
ClientAdded?.Invoke(this, null);
}
