/// <summary>
/// Registers a delegate to retrieve instances of the specified type.
/// </summary>
public PocketContainer Register <T>(Func <PocketContainer, T> factory)
{
var replaced = (Func <PocketContainer, object>)Registering?.Invoke(typeof(T), factory);
if (replaced != null)
{
factory = c => (T)replaced(c);
}
resolvers[typeof(T)] = c => factory(c);
resolvers[typeof(Lazy <T>)] = c => new Lazy <T>(c.Resolve <T>);
return(this);
}
private async void newRegistrationSent(IAsyncOperation <uint> info, AsyncStatus status)
{
if (status == AsyncStatus.Completed)
{
Registering?.Invoke();
await ListenForRegistrationResponse();
}
else
{
RegistrationFailed?.Invoke();
ConnectionState = TvConnectionState.Disconnected;
}
}
/// <summary>
/// Resolves an instance of the specified type.
/// </summary>
public T Resolve <T>()
{
var resolved = (T)resolvers.GetOrAdd(typeof(T), _ =>
{
var implicitResolver = ImplicitResolver <T>();
if (Registering?.Invoke(typeof(T), implicitResolver) is Func <PocketContainer, object> replacedResolver)
{
implicitResolver = c => (T)replacedResolver(c);
}
return(implicitResolver);
})(this);
return(CallAfterResolve(typeof(T), resolved, out var replaced)
? (T)replaced
: resolved);
}
/// <inheritdoc />
/// <summary>
/// Registers the specified character spawn.
/// </summary>
/// <param name="characterSpawn">The character spawn.</param>
public void Register(ICharacterSpawn characterSpawn)
{
if (Members.ContainsKey(characterSpawn.Id))
{
return;
}
ChannelRegisteringEventArgs channelRegisteringEventArgs = new ChannelRegisteringEventArgs(characterSpawn);
Registering?.Invoke(this, channelRegisteringEventArgs);
if (channelRegisteringEventArgs.Cancel)
{
return;
}
Members.Add(characterSpawn.Id, characterSpawn);
ChannelRegisteredEventArgs channelRegisteredEventArgs = new ChannelRegisteredEventArgs(characterSpawn);
Registered?.Invoke(this, channelRegisteredEventArgs);
}
/// <summary>
/// RegisterType a type mapping with the container, where the created instances will use
/// the given <see cref="LifetimeManager"/>.
/// </summary>
/// <param name="typeFrom"><see cref="Type"/> that will be requested.</param>
/// <param name="typeTo"><see cref="Type"/> that will actually be returned.</param>
/// <param name="name">Name to use for registration, null if a default registration.</param>
/// <param name="lifetimeManager">The <see cref="LifetimeManager"/> that controls the lifetime
/// of the returned instance.</param>
/// <param name="injectionMembers">Injection configuration objects.</param>
/// <returns>The <see cref="UnityContainer"/> object that this method was called on (this in C#, Me in Visual Basic).</returns>
public IUnityContainer RegisterType(Type typeFrom, Type typeTo, string name, LifetimeManager lifetimeManager, InjectionMember[] injectionMembers)
{
// Validate imput
var to = typeTo ?? throw new ArgumentNullException(nameof(typeTo));
if (typeFrom != null && !typeFrom.GetTypeInfo().IsGenericType&& !to.GetTypeInfo().IsGenericType)
{
if (!typeFrom.GetTypeInfo().IsAssignableFrom(to.GetTypeInfo()))
{
throw new ArgumentException(string.Format(CultureInfo.CurrentCulture,
Constants.TypesAreNotAssignable, typeFrom, to), nameof(typeFrom));
}
}
// Register type
var registration = new TypeRegistration(typeFrom, typeTo, name, lifetimeManager, injectionMembers);
var old = SetOrUpdate(registration.RegisteredType, registration.Name, registration);
if (old is IDisposable disposable)
{
_lifetimeContainer.Remove(disposable);
disposable.Dispose();
}
Registering?.Invoke(this, new RegisterEventArgs(registration.RegisteredType, registration.MappedToType, registration.Name, registration.LifetimeManager));
if (null != injectionMembers && injectionMembers.Length > 0)
{
var proxy = new PolicyListProxy(_context, registration);
foreach (var member in injectionMembers)
{
member.AddPolicies(registration.RegisteredType, registration.MappedToType, registration.Name, proxy);
}
}
return(this);
}
/// <summary>
/// Called by the container when the service type is registering.
/// </summary>
/// <param name="e">The event argument.</param>
protected virtual void OnRegistering(ServiceRegisterEventArgs e)
{
Registering?.Invoke(this, e);
}
private void BtnEditAdd_OnClick(object sender, RoutedEventArgs e)
{
try
{
int type = 0;
int num = Convert.ToInt32(TxtNum.Text);
var q = Context.Students.SingleOrDefault(i => i.StuNumber == num && !i.isDeleted);
if (ComType.Text == "تسجيل كمستجد")
{
type = 0;
}
else if (ComType.Text == "إيقاف التسجيل")
{
type = 1;
}
else
{
type = 2;
}
if (BtnEditAdd.IsChecked == true)
{
try
{
Registering = new Registering
{
RegDate = Convert.ToDateTime(DpReg.Text),
StudentId = q.Id,
RegType = type
};
Context.Registerings.Add(Registering);
}
catch
{
MessageBox.Show(" عذراً ! هناك خطأ في الرقم الجامعي ", "", MessageBoxButton.OK, MessageBoxImage.Error);
BtnEditAdd.IsChecked = false;
return;
}
}
else
{
try
{
var queryUpdate = Context.Registerings.SingleOrDefault(i => !i.isDeleted && i.Id == EditID);
queryUpdate.StudentId = q.Id;
queryUpdate.RegDate = Convert.ToDateTime(DpReg.Text);
queryUpdate.RegType = type;
}
catch
{
MessageBox.Show(" عذراً ! هناك خطأ في الرقم الجامعي ", "", MessageBoxButton.OK, MessageBoxImage.Error);
BtnEditAdd.IsChecked = true;
return;
}
}
TxtNum.Text = "";
DpReg.Text = "";
ComType.Text = "";
BtnEditAdd.IsChecked = false;
Context.SaveChanges();
Load();
}
catch
{
}
}
public ActionResult Register(Registering registering)
{
if (registering != null)
{
using (var db = new MyDbContext())
{
if (string.IsNullOrWhiteSpace(registering.Email) || string.IsNullOrWhiteSpace(registering.Password) || string.IsNullOrWhiteSpace(registering.ConfirmPassword))
{
registering.OutcomeOfCheckRegistration = "SomeNullInput";
return(View("RegisterPage", registering));
}
var query = from b in db.ClientsTable
orderby b.ClientId
select b;
var testEmailAddress = new EmailAddressAttribute();
bool emailIsValid = testEmailAddress.IsValid(registering.Email);
bool isNewEmail = true;
foreach (var item in query)
{
if (item.Email.Equals(registering.Email))
{
isNewEmail = false;
}
}
if (emailIsValid)
{
if (isNewEmail)
{
if (registering.Password == registering.ConfirmPassword)
{
var newClient = new Client
{
Email = registering.Email,
Password = registering.Password
};
db.ClientsTable.Add(newClient);
db.SaveChanges();
registering.OutcomeOfCheckRegistration = "Passed";
return(View("RegisterPage", registering));
}
else
{
registering.OutcomeOfCheckRegistration = "Confirm Password need to match Password";
return(View("RegisterPage", registering));
}
}
else
{
registering.OutcomeOfCheckRegistration = "Sorry, that username's taken. Try another?";
return(View("RegisterPage", registering));
}
}
else
{
registering.OutcomeOfCheckRegistration = "Invalid Email";
return(View("RegisterPage", registering));
}
}
}
else
{
return(null);
}
}
public ActionResult RegisterPage()
{
var registering = new Registering();
return(View(registering));
}
